#ifndef __M_UTIL_H__
#define __M_UTIL_H__

#include "log.hpp"
#include <iostream>
#include <string>
#include <vector>
#include <mysql/mysql.h>
#include <jsoncpp/json/json.h>
#include <memory>
#include <sstream>
#include <fstream>
#include <websocketpp/server.hpp>
#include <websocketpp/config/asio_no_tls.hpp> // 非ssl/tls加密
#include <mutex>

typedef websocketpp::server<websocketpp::config::asio> wsserver_t;

class mysql_util
{
public:
    // 初始化mysql数据库
    static MYSQL *mysql_create(const std::string &host,
                               const std::string &usr,
                               const std::string &pwd,
                               const std::string &db,
                               const uint16_t port = 3306 /* 为0也可，默认设置为3306 */)
    {
        // 1. 初始化mysql句柄
        MYSQL *mysql = mysql_init(NULL);
        if (mysql == NULL)
        {
            ERR_LOG("mysql init failed!");
            return NULL;
        }

        // 2. 连接服务器
        if (mysql_real_connect(mysql, host.c_str(), usr.c_str(), pwd.c_str(), db.c_str(), port, NULL, 0) == NULL)
        {
            ERR_LOG("mysql server connect fialed : %s", mysql_error(mysql));
            mysql_close(mysql);
            return NULL;
        }

        // 3. 设置客户端字符集
        if (mysql_set_character_set(mysql, "utf8") != 0)
        {
            ERR_LOG("client set character_set fialed : %s", mysql_error(mysql));
            mysql_close(mysql);
            return NULL;
        }

        return mysql;
    }

    // 执行mysql语句
    static bool mysql_exec(MYSQL *mysql, const std::string &sql)
    {
        int ret = mysql_query(mysql, sql.c_str());
        if (ret != 0)
        {
            ERR_LOG("%s\n", sql.c_str());
            ERR_LOG("mysql query fialed : %s", mysql_error(mysql));
            /* [2024/05/28-23:15:42 util.hpp:58] mysql query fialed : Your password does not satisfy the current policy requirements */
            // mysql_close(mysql);
            return false;
        }

        return true;
    }

    // 销毁mysql操作句柄
    static void mysql_destory(MYSQL *mysql)
    {
        if (mysql != NULL)
            mysql_close(mysql);
    }
};

class json_util
{
public:
    static bool serialize(const Json::Value &root, std::string *out)
    {
        // 2. 实例化一个StreamWriterBuilder工厂类对象
        Json::StreamWriterBuilder swb;
        // 3. 通过StreamWriterBuilder工厂类对象生产一个StreamWriter对象
        std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
        // 4. 使用StreamWriter对象对Json::Value中的数据做序列化
        std::stringstream ss;
        int n = sw->write(root, &ss);
        if (n != 0)
        {
            ERR_LOG("json serialize failed!");
            return false;
        }

        *out = ss.str();

        return true;
    }
    static bool unserialize(const std::string &in, Json::Value *root)
    {
        // 1. 实例化一个CharReaderBuilder工厂类对象
        Json::CharReaderBuilder crb;
        // 2. 通过CharReaderBuilder工厂类对象生产一个CharReader对象
        std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
        // 3. 实例化一个Json::Value对象用来存储解析出的数据
        // Json::Value root;
        // 4. 使用CharReader对象进行json格式字符串str的反序列化
        std::string err;
        bool ret = cr->parse(in.c_str(), in.c_str() + in.size(), root, &err);
        if (ret == false)
        {
            ERR_LOG("unserialize failed: %s", err.c_str());
            return false;
        }

        return true;
    }
};

class string_util
{
public:
    static int split(const std::string &in, const std::string &sep, std::vector<std::string> &res)
    {
        size_t pos, index = 0;
        while (index < in.size())
        {
            // 1. 从指定位置查找字符串
            pos = in.find(sep, index);
            if (pos == std::string::npos)
            {
                // 1.1 没找到——将从index开始的字符串插入，结束查找
                res.push_back(in.substr(index));
                break;
            }
            // 1.2 找到了
            if (pos == index) // 连续重复分割符
            {
                index += sep.size();
                continue;
            }
            // 单分隔符
            res.push_back(in.substr(index, pos - index));
            index = pos + sep.size();
        }

        return res.size();
    }
};

class file_util
{
public:
    static bool read(std::string& filename, std::string* body)
    {
        // 1. 打开文件——将外设的数据加载读取到内存
        std::ifstream ifs(filename, std::ios::binary);// 要以二进制的方式打开，因为文件中可能不仅仅只有文本内容
        if(ifs.is_open() == false)
        {
            ERR_LOG("%s file open failed!", filename.c_str());
            return false;
        }
        // 2. 获取文件大小
        size_t fsize = 0;
        ifs.seekg(0, std::ios::end);// 移动读取位置到文件末尾
        fsize = ifs.tellg();// 获取当前读取位置的偏移量
        ifs.seekg(0, std::ios::beg);// 重置，移动读取位置到文件起始位置

        // 3. 将文件中所有数据读取出来
        body->resize(fsize);
        ifs.read(&(*body)[0]/* 通过访问第一个元素获取body首地址 */, fsize);
        if(ifs.good() == false)
        {
            ERR_LOG("%s read file content failed!", filename.c_str());
            return false;
        }
        // 4. 关闭文件
        ifs.close();

        return true;
    }
};

#endif